import { ToolCall } from '../types';

export class ToolCallParser {
  static parseResponse(content: string): {
    hasToolCall: boolean;
    toolCall: ToolCall | null;
    remainingContent: string;
    parseError?: string;
  } {
    // 匹配XML格式的工具调用
    const xmlRegex = /<function_calls>([\s\S]*?)<\/function_calls>/;
    const match = content.match(xmlRegex);
    
    if (!match) {
      return {
        hasToolCall: false,
        toolCall: null,
        remainingContent: content
      };
    }

    let remainingContent = content;
    let toolCall: ToolCall | null = null;
    let parseError: string | undefined = undefined;

    try {
      const xmlContent = match[1].trim();
      
      // 检查XML内容是否为空
      if (!xmlContent) {
        parseError = '工具调用内容为空，请提供有效的XML格式';
        throw new Error('Empty function call block');
      }
      
      // 解析invoke标签获取工具名
      const invokeRegex = /<invoke\s+name="([^"]+)">([\s\S]*?)<\/invoke>/;
      const invokeMatch = xmlContent.match(invokeRegex);
      
      if (!invokeMatch) {
        parseError = '缺少工具名称。正确格式：\n<function_calls>\n<invoke name="工具名">\n<parameter name="参数名">参数值</parameter>\n</invoke>\n</function_calls>';
        throw new Error('Missing invoke tag or tool name');
      }
      
      const toolName = invokeMatch[1];
      const parametersContent = invokeMatch[2].trim();
      
      // 解析parameters
      const toolArguments: Record<string, any> = {};
      
      if (parametersContent) {
        // 匹配所有parameter标签
        const paramRegex = /<parameter\s+name="([^"]+)">([\s\S]*?)<\/parameter>/g;
        let paramMatch;
        
        while ((paramMatch = paramRegex.exec(parametersContent)) !== null) {
          const paramName = paramMatch[1];
          let paramValue = paramMatch[2].trim();
          
          // 尝试解析JSON值（如对象、数组等）
          try {
            // 如果值看起来像JSON，尝试解析
            if ((paramValue.startsWith('{') && paramValue.endsWith('}')) ||
                (paramValue.startsWith('[') && paramValue.endsWith(']')) ||
                paramValue === 'true' || paramValue === 'false' ||
                paramValue === 'null' ||
                !isNaN(Number(paramValue))) {
              toolArguments[paramName] = JSON.parse(paramValue);
            } else {
              // 普通字符串值
              toolArguments[paramName] = paramValue;
            }
          } catch {
            // JSON解析失败，当作字符串处理
            toolArguments[paramName] = paramValue;
          }
        }
      }
      
      // 构建ToolCall对象
      toolCall = {
        id: `call_${Date.now()}`,
        type: 'function' as const,
        function: {
          name: toolName,
          arguments: toolArguments
        }
      };
      
      // 从剩余内容中移除工具调用XML块
      remainingContent = remainingContent.replace(match[0], '').trim();
      
    } catch (e) {
      // 解析失败，生成详细的错误信息
      const errorMessage = e instanceof Error ? e.message : String(e);
      const xmlContent = match[1].trim();
      
      if (!parseError) {
        parseError = `XML解析失败: ${errorMessage}。\n请使用正确的格式:\n<function_calls>\n<invoke name="工具名">\n<parameter name="参数名">参数值</parameter>\n</invoke>\n</function_calls>\n\n当前内容:\n\`\`\`\n${xmlContent}\n\`\`\``;
      }
      
      console.error('XML工具调用解析失败:', {
        error: errorMessage,
        xmlContent: xmlContent,
        fullMatch: match[0]
      });
    }
    
    return {
      hasToolCall: toolCall !== null,
      toolCall,
      remainingContent,
      parseError
    };
  }
}